package com.crab.c05sorting;

import java.util.Arrays;

/**
 * 冒泡法
 *
 * @author zfd
 * @version v1.0
 * @date 2022/4/29 14:29
 */
public class BunbleSort {
    public static void main(String[] args) {
        int[] array = new int[]{3, 4, 2, 1, 5, 6, 7, 8};

        /*sortV1(array);
        System.out.println();*/

        array = new int[]{3, 4, 2, 1, 5, 6, 7, 8};
        sortV2(array);
        System.out.println();

        array = new int[]{3, 4, 2, 1, 5, 6, 7, 8};
        sortV3(array);
        System.out.println();

        array = new int[]{2, 3, 4, 5, 6, 7, 1, 8};
        sortV4(array);
        System.out.println();
    }

    /**
     * 版本1
     *
     * @param array
     */
    public static void sortV1(int[] array) {
        // 外部循环控制所有回合
        for (int i = 0; i < array.length - 1; i++) {
            System.out.print("进行排序的轮数：" + (i + 1) + "    当前轮的无序区元素数：" + (array.length - 1 - i));
            // 内部控制每一轮冒泡
            // 每轮右边有序的元素增加1 故j的范围会越来越小
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    // 左大于右 交换
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                }
            }
            System.out.println("     当前轮排序后数组：" + Arrays.toString(array));
        }
    }

    /**
     * v2 优化1：某一轮有序后，后面的轮不再进行
     *
     * @param array
     */
    public static void sortV2(int[] array) {
        // 外部循环控制所有回合
        for (int i = 0; i < array.length - 1; i++) {

            // 当前轮是否已经有序的标记，没有交换就是有序
            boolean isSorted = true;

            System.out.print("进行排序的轮数：" + (i + 1) + "    当前轮的无序区元素数：" + (array.length - 1 - i));
            // 内部控制每一轮冒泡
            // 每轮右边有序的元素增加1 故j的范围会越来越小
            for (int j = 0; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    // 左大于右 交换
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    // 交换了代表无序
                    isSorted = false;
                }
            }
            System.out.println("     当前轮排序后数组：" + Arrays.toString(array));
            // 已经有序跳出大循环
            if (isSorted) {
                break;
            }
        }
    }

    /**
     * v3 优化2：在v2的基础上记录有序区的边界，有序区不需要冒泡
     *
     * @param array
     */
    public static void sortV3(int[] array) {
        // 最后交换的位置
        int lastExchangeIndex = 0;
        // 有序区的边界 每次只需要比较到这个位置
        int sortBorder = array.length - 1;


        // 外部循环控制所有回合
        for (int i = 0; i < array.length - 1; i++) {

            // 当前轮是否已经有序的标记，没有交换就是有序
            boolean isSorted = true;

            System.out.print("进行排序的轮数：" + (i + 1) + "    当前轮的无序区元素数：" + (array.length - 1 - i));
            System.out.print("    有序区的边界：" + sortBorder);
            // 内部控制每一轮冒泡
            // 每轮右边有序的元素增加1 故j的范围会越来越小
            for (int j = 0; j < sortBorder; j++) {
                if (array[j] > array[j + 1]) {
                    // 左大于右 交换
                    int temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    // 交换了代表无序
                    isSorted = false;
                    // 记录交换位置
                    lastExchangeIndex = j;
                }
            }
            System.out.println("     当前轮排序后数组：" + Arrays.toString(array));
            // 更新有序边界
            sortBorder = lastExchangeIndex;
            // 已经有序跳出大循环
            if (isSorted) {
                break;
            }
        }
    }

    /**
     * 鸡尾酒排序 类似钟摆 左一轮 右一轮
     * 代码量复杂些 应用于大部分有序的场景
     *
     * @param array
     */
    public static void sortV4(int[] array) {
        int temp = 0;
        // 外部循环控制所有回合
        for (int i = 0; i < array.length / 2; i++) {
            System.out.print("进行排序的轮数：" + (i + 1));

            // 当前轮是否已经有序的标记，没有交换就是有序
            boolean isSorted = true;
            // 1 从左到右
            for (int j = i; j < array.length - 1 - i; j++) {
                if (array[j] > array[j + 1]) {
                    // 左大于右 交换
                    temp = array[j];
                    array[j] = array[j + 1];
                    array[j + 1] = temp;
                    // 交换了代表无序
                    isSorted = false;
                }
            }
            System.out.println("     当前轮排序后数组：" + Arrays.toString(array));
            // 已经有序跳出大循环
            if (isSorted) {
                break;
            }

            // 2 从右到左
            isSorted = true;
            for (int j = array.length - 1; j > i; j--) {
                temp = array[j];
                if (array[j] < array[j - 1]) {
                    array[j] = array[j - 1];
                    array[j - 1] = temp;
                    isSorted = false;
                }
            }
            if (isSorted) {
                break;
            }
        }
    }
}
